World-wide virtual machine: A metacomputing environment integrating World Wide Web and high performance computing and communications technologies

This thesis discusses the major issues in building a metacomputing environment based on World-Wide Web (WWW) and High Performance Computing and Communication (HPCC) technologies and describes the design and implementation of such an environment called World Wide Virtual Machine (WWVM). The presented work helps to carry much of the past decade\u27s work in HPCC technologies to the larger WWW domain. The WWVM exploits the open interfaces brought by Web servers. It extends the servers via Common Gateway Interface (CGI) extensions and uses PVM daemons and low-level protocols such as HTTP, TCP/IP, and UDP/IP in order to combine remote networked computers as a single machine. The WWVM can work in stand-alone, message-passing, and dataflow modes and provides the interoperability of many diverse software and hardware components. The stand-alone mode allows computations to be performed on a remote WWVM server or any other machine coordinated by a server. In the message-passing mode, the WWVM is capable of executing message-passing PVM and MPI programs, and High Performance Fortran (HPF) programs compiled by the Syracuse Fortran 90D/HPF compiler, as well as parallel programs using PCRC or Global Arrays runtime support libraries. In the dataflow mode, WWVM\u27s coordination layer interprets a simple task flow (data-dependency) description language to deduct the dataflow patterns between different WWVM nodes. The WWVM supplies an integrated, Web-based programming environment and gives pervasive access to remote WWVM facilities from any platform (Unix, PC, or Mac) using a standard Web browser. Client-side Web technologies such as HTML, JavaScript, plug-ins, and Java supply a platform-independent graphical user interface and visualization capabilities that include analyzing data output from programs and performance information recorded in Pablo\u27s SDDF format. The associated data wrapper libraries provide real-time, application-specific data display and computational steering capabilities by providing a link between running parallel programs and client-side Java applets

jmpi and a Performance Instrumentation Analysis and Visualization Tool for jmpi

jmpi is a 100% Java-based implementation of the Message-Passing Interface (MPI-1) standard. jmpi comes with a consistent MPI object model suitable for Java. Its Application Programming Interface (API) is similar to the standard C bindings of MPI. jmpi is integrated with a performance instrumentation, analysis, and visualization system called JPVS, that is also implemented in Java. Instrumented jmpi routines generate execution trace files in Pablo's SDDF format. These trace files are processed by the JPVS and processor- and communication-oriented static and dynamic performance displays are generated to help jmpi users to observe the behavior of their programs. We give sample displays from the JPVS along with some early performance results of a set of jmpi benchmark codes on a cluster of SUN UltraSparc workstations

jmpi and a Performance Instrumentation Analysis and ABSTRACT Visualization Tool for jmpi

jmpi is a 100 % Java-based implementation of the Message-Passing Interface (MPI-1) standard. jmpi comes with a consistent MPI object model suitable for Java. Its Application Programming Interface (API) is similar to the standard C bindings of MPI. jmpi is integrated with a performance instrumentation, analysis, and visualization system called JPVS, that is also implemented in Java. Instrumented jmpi routines generate execution trace files in Pablo’s SDDF format. These trace files are processed by the JPVS and processor- and communication-oriented static and dynamic performance displays are generated to help jmpi users to observe the behavior of their programs. We give sample displays from the JPVS along with some early performance results of a set of jmpi benchmark codes on a cluster of SUN UltraSparc workstations

Using Java and JavaScript in the Virtual Programming Laboratory: A Web-Based Parallel Programming Environment

The Virtual Programming Laboratory (VPL) is a Web-based virtual programming environment built based on a client-server architecture. The system can be accessed on any platform (Unix, PC, or Mac) using a standard Java-enabled browser. Software delivery over the Web imposes a novel set of constraints on design. We outline the tradeoffs in this design space, motivate the choices necessary to deliver an application, and detail the lessons learned in the process. We discuss the role of Java and other Web technologies in the realization of the design. VPL facilitates the development and execution of parallel programs. The initial prototype supports high-level parallel programming based on Fortran 90 and High Performance Fortran (HPF), as well as explicit low-level programming with the MPI message-passing interface. Supplementary Java-based platform-independent tools for data and performance visualization are an integral part of the VPL. Pablo SDDF trace files generated by the Pablo performan..

Benchmarking the Computation and Communication Performance of the CM-5

Thinking Machines' CM-5 machine is a distributed-memory, message-passing computer. In this paper we devise a performance benchmark for the base and vector units and the data communication networks of the CM-5 machine. We model the communication characteristics such as communication latency and bandwidths of point-to-point and global communication primitives. We show, on a simple Gaussian elimination code, that an accurate static performance estimation of parallel algorithms is possible by using those basic machine properties connected with computation, vectorization, communication, and synchronization. Furthermore, we describe the embedding of meshes or hypercubes on the CM-5 fat-tree topology and illustrate the performance results of their basic communication primitives. 1 This work was supported in part by NSF under CCR-9110812 and by DARPA under contract # DABT63-91-C-0028. This work was also supported in part by a grant of HPC time from the DoD HPC Shared Resource Center, Army Hig..